home *** CD-ROM | disk | FTP | other *** search
/ ETO Development Tools 1 / ETO Development Tools 1.iso / Essentials / Developer Essentials Jul 90 / Programming / MPW Interfaces & Libraries 3.1 / CIncludes / AppleTalk.h next >
Encoding:
C/C++ Source or Header  |  1989-10-13  |  18.0 KB  |  593 lines  |  [TEXT/MPS ]

  1. /************************************************************
  2.  
  3. Created: Thursday, September 7, 1989 at 3:04 PM
  4.     AppleTalk.h
  5.     C Interface to the Macintosh Libraries
  6.  
  7.  
  8.     Copyright Apple Computer, Inc. 1985-1989
  9.     All rights reserved
  10.  
  11. ************************************************************/
  12.  
  13.  
  14. #ifndef __APPLETALK__
  15. #define __APPLETALK__
  16.  
  17. #ifndef __TYPES__
  18. #include <Types.h>
  19. #endif
  20.  
  21. #ifndef __OSUTILS__
  22. #include <OSUtils.h>
  23. #endif
  24.  
  25. #define afpByteRangeLock 1        /*AFPCall command codes*/
  26. #define afpVolClose 2            /*AFPCall command codes*/
  27. #define afpDirClose 3            /*AFPCall command codes*/
  28. #define afpForkClose 4            /*AFPCall command codes*/
  29. #define afpCopyFile 5            /*AFPCall command codes*/
  30. #define afpDirCreate 6            /*AFPCall command codes*/
  31. #define afpFileCreate 7         /*AFPCall command codes*/
  32. #define afpDelete 8             /*AFPCall command codes*/
  33. #define afpEnumerate 9            /*AFPCall command codes*/
  34. #define afpFlush 10             /*AFPCall command codes*/
  35. #define afpForkFlush 11         /*AFPCall command codes*/
  36. #define afpGetDirParms 12        /*AFPCall command codes*/
  37. #define afpGetFileParms 13        /*AFPCall command codes*/
  38. #define afpGetForkParms 14        /*AFPCall command codes*/
  39. #define afpGetSInfo 15            /*AFPCall command codes*/
  40. #define afpGetSParms 16         /*AFPCall command codes*/
  41. #define afpGetVolParms 17        /*AFPCall command codes*/
  42. #define afpLogin 18             /*AFPCall command codes*/
  43. #define afpContLogin 19         /*AFPCall command codes*/
  44. #define afpLogout 20            /*AFPCall command codes*/
  45. #define afpMapID 21             /*AFPCall command codes*/
  46. #define afpMapName 22            /*AFPCall command codes*/
  47. #define afpMove 23                /*AFPCall command codes*/
  48. #define afpOpenVol 24            /*AFPCall command codes*/
  49. #define afpOpenDir 25            /*AFPCall command codes*/
  50. #define afpOpenFork 26            /*AFPCall command codes*/
  51. #define afpRead 27                /*AFPCall command codes*/
  52. #define afpRename 28            /*AFPCall command codes*/
  53. #define afpSetDirParms 29        /*AFPCall command codes*/
  54. #define afpSetFileParms 30        /*AFPCall command codes*/
  55. #define afpSetForkParms 31        /*AFPCall command codes*/
  56. #define afpSetVolParms 32        /*AFPCall command codes*/
  57. #define afpWrite 33             /*AFPCall command codes*/
  58. #define afpGetFlDrParms 34        /*AFPCall command codes*/
  59. #define afpSetFlDrParms 35        /*AFPCall command codes*/
  60. #define afpDTOpen 48            /*AFPCall command codes*/
  61. #define afpDTClose 49            /*AFPCall command codes*/
  62. #define afpGetIcon 51            /*AFPCall command codes*/
  63. #define afpGtIcnInfo 52         /*AFPCall command codes*/
  64. #define afpAddAPPL 53            /*AFPCall command codes*/
  65. #define afpRmvAPPL 54            /*AFPCall command codes*/
  66. #define afpGetAPPL 55            /*AFPCall command codes*/
  67. #define afpAddCmt 56            /*AFPCall command codes*/
  68. #define afpRmvCmt 57            /*AFPCall command codes*/
  69. #define afpGetCmt 58            /*AFPCall command codes*/
  70. #define afpAddIcon 192            /*Special code for ASP Write commands*/
  71. #define xppLoadedBit 5            /* XPP bit in PortBUse */
  72. #define xppUnitNum 40            /*Unit number for XPP (old ROMs) */
  73. #define xppRefNum -41            /*.XPP reference number */
  74. #define scbMemSize 192            /*Size of memory for SCB */
  75. #define xppFlagClr 0            /*Cs for AFPCommandBlock */
  76. #define xppFlagSet 128            /*StartEndFlag & NewLineFlag fields. */
  77. #define lapSize 20
  78. #define ddpSize 26
  79. #define nbpSize 26
  80. #define atpSize 56
  81. #define MPPioCompletion MPP.ioCompletion
  82. #define MPPioResult MPP.ioResult
  83. #define MPPioRefNum MPP.ioRefNum
  84. #define MPPcsCode MPP.csCode
  85. #define LAPprotType LAP.protType
  86. #define LAPwdsPointer LAP.LAPptrs.wdsPointer
  87. #define LAPhandler LAP.LAPptrs.handler
  88. #define DDPsocket DDP.socket
  89. #define DDPchecksumFlag DDP.checksumFlag
  90. #define DDPwdsPointer DDP.DDPptrs.wdsPointer
  91. #define DDPlistener DDP.DDPptrs.listener
  92. #define NBPinterval NBP.interval
  93. #define NBPcount NBP.count
  94. #define NBPntQElPtr NBP.NBPPtrs.ntQElPtr
  95. #define NBPentityPtr NBP.NBPPtrs.entityPtr
  96. #define NBPverifyFlag NBP.parm.verifyFlag
  97. #define NBPretBuffPtr NBP.parm.Lookup.retBuffPtr
  98. #define NBPretBuffSize NBP.parm.Lookup.retBuffSize
  99. #define NBPmaxToGet NBP.parm.Lookup.maxToGet
  100. #define NBPnumGotten NBP.parm.Lookup.numGotten
  101. #define NBPconfirmAddr NBP.parm.Confirm.confirmAddr
  102. #define NBPnKillQEl NBPKILL.nKillQEl
  103. #define NBPnewSocket NBP.parm.Confirm.newSocket
  104. #define ATPioCompletion ATP.ioCompletion
  105. #define ATPioResult ATP.ioResult
  106. #define ATPuserData ATP.userData
  107. #define ATPreqTID ATP.reqTID
  108. #define ATPioRefNum ATP.ioRefNum
  109. #define ATPcsCode ATP.csCode
  110. #define ATPatpSocket ATP.atpSocket
  111. #define ATPatpFlags ATP.atpFlags
  112. #define ATPaddrBlock ATP.addrBlock
  113. #define ATPreqLength ATP.reqLength
  114. #define ATPreqPointer ATP.reqPointer
  115. #define ATPbdsPointer ATP.bdsPointer
  116. #define ATPtimeOutVal SREQ.timeOutVal
  117. #define ATPnumOfResps SREQ.numOfResps
  118. #define ATPretryCount SREQ.retryCount
  119. #define ATPnumOfBuffs OTH1.u0.numOfBuffs
  120. #define ATPbitMap OTH1.u0.bitMap
  121. #define ATPrspNum OTH1.u0.rspNum
  122. #define ATPbdsSize OTH2.bdsSize
  123. #define ATPtransID OTH2.transID
  124. #define ATPaKillQEl KILL.aKillQEl
  125. #define atpXOvalue 32            /*ATP exactly-once bit */
  126. #define atpEOMvalue 16            /*ATP End-Of-Message bit */
  127. #define atpSTSvalue 8            /*ATP Send-Transmission-Status bit */
  128. #define atpTIDValidvalue 2        /*ATP trans. ID valid bit */
  129. #define atpSendChkvalue 1        /*ATP send checksum bit */
  130.  
  131. enum {tLAPRead,tLAPWrite,tDDPRead,tDDPWrite,tNBPLookup,tNBPConfirm,tNBPRegister,
  132.     tATPSndRequest,tATPGetRequest,tATPSdRsp,tATPAddRsp,tATPRequest,tATPResponse};
  133. typedef unsigned char ABCallType;
  134.  
  135. enum {lapProto,ddpProto,nbpProto,atpProto};
  136. typedef unsigned char ABProtoType;
  137.  
  138. typedef unsigned char ABByte;
  139.  
  140. typedef char BitMapType;
  141.  
  142. typedef char Str32[33];
  143.  
  144. struct LAPAdrBlock {
  145.     unsigned char dstNodeID;
  146.     unsigned char srcNodeID;
  147.     ABByte lapProtType;
  148. };
  149.  
  150. typedef struct LAPAdrBlock LAPAdrBlock;
  151. struct AddrBlock {
  152.     short aNet;
  153.     unsigned char aNode;
  154.     unsigned char aSocket;
  155. };
  156.  
  157. typedef struct AddrBlock AddrBlock;
  158. struct EntityName {
  159.     Str32 objStr;
  160.     char pad1;                    /*Str32's aligned on even word boundries.*/
  161.     Str32 typeStr;
  162.     char pad2;
  163.     Str32 zoneStr;
  164.     char pad3;
  165. };
  166.  
  167. typedef struct EntityName EntityName;
  168. typedef EntityName *EntityPtr;
  169.  
  170. /* Real definition of EntityName is 3 PACKED strings of any length (32 is just an example). No
  171. offests for Asm since each String address must be calculated by adding length byte to last string ptr.
  172. In Pascal, String(32) will be 34 bytes long since fields never start on an odd byte unless they are 
  173. only a byte long. So this will generate correct looking interfaces for Pascal and C, but they will not
  174. be the same, which is OK since they are not used. */
  175. struct RetransType {
  176.     unsigned char retransInterval;
  177.     unsigned char retransCount;
  178. };
  179.  
  180. typedef struct RetransType RetransType;
  181. struct BDSElement {
  182.     short buffSize;
  183.     Ptr buffPtr;
  184.     short dataSize;
  185.     long userBytes;
  186. };
  187.  
  188. typedef struct BDSElement BDSElement;
  189. typedef BDSElement BDSType[8];
  190. typedef BDSType *BDSPtr;
  191.  
  192.  
  193. struct ATLAPRec {
  194.     ABCallType abOpcode;
  195.     short abResult;
  196.     long abUserReference;
  197.     LAPAdrBlock lapAddress;
  198.     short lapReqCount;
  199.     short lapActCount;
  200.     Ptr lapDataPtr;
  201. };
  202.  
  203. typedef struct ATLAPRec ATLAPRec;
  204. typedef ATLAPRec *ATLAPRecPtr, **ATLAPRecHandle;
  205.  
  206. struct ATDDPRec {
  207.     ABCallType abOpcode;
  208.     short abResult;
  209.     long abUserReference;
  210.     short ddpType;
  211.     short ddpSocket;
  212.     AddrBlock ddpAddress;
  213.     short ddpReqCount;
  214.     short ddpActCount;
  215.     Ptr ddpDataPtr;
  216.     short ddpNodeID;
  217. };
  218.  
  219. typedef struct ATDDPRec ATDDPRec;
  220. typedef ATDDPRec *ATDDPRecPtr, **ATDDPRecHandle;
  221.  
  222. struct ATNBPRec {
  223.     ABCallType abOpcode;
  224.     short abResult;
  225.     long abUserReference;
  226.     EntityPtr nbpEntityPtr;
  227.     Ptr nbpBufPtr;
  228.     short nbpBufSize;
  229.     short nbpDataField;
  230.     AddrBlock nbpAddress;
  231.     RetransType nbpRetransmitInfo;
  232. };
  233.  
  234. typedef struct ATNBPRec ATNBPRec;
  235. typedef ATNBPRec *ATNBPRecPtr, **ATNBPRecHandle;
  236.  
  237. struct ATATPRec {
  238.     ABCallType abOpcode;
  239.     short abResult;
  240.     long abUserReference;
  241.     short atpSocket;
  242.     AddrBlock atpAddress;
  243.     short atpReqCount;
  244.     Ptr atpDataPtr;
  245.     BDSPtr atpRspBDSPtr;
  246.     BitMapType atpBitMap;
  247.     short atpTransID;
  248.     short atpActCount;
  249.     long atpUserData;
  250.     Boolean atpXO;
  251.     Boolean atpEOM;
  252.     short atpTimeOut;
  253.     short atpRetries;
  254.     short atpNumBufs;
  255.     short atpNumRsp;
  256.     short atpBDSSize;
  257.     long atpRspUData;
  258.     Ptr atpRspBuf;
  259.     short atpRspSize;
  260. };
  261.  
  262. typedef struct ATATPRec ATATPRec;
  263. typedef ATATPRec *ATATPRecPtr, **ATATPRecHandle;
  264.  
  265. typedef struct {
  266.     char cmdByte;
  267.     char startEndFlag;
  268.     short forkRefNum;
  269.     long rwOffset;
  270.     long reqCount;
  271.     char newLineFlag;
  272.     char newLineChar;
  273. }AFPCommandBlock;
  274.  
  275. #define XPPPBHeader \
  276.     QElem *qLink;\
  277.     short qType;\
  278.     short ioTrap;\
  279.     Ptr ioCmdAddr;\
  280.     ProcPtr ioCompletion;\
  281.     OSErr ioResult;\
  282.     long cmdResult;\
  283.     short ioVRefNum;\
  284.     short ioRefNum;\
  285.     short csCode;
  286.  
  287.  
  288. typedef struct {
  289.     XPPPBHeader 
  290.     short sessRefnum;            /*Offset to session refnum*/
  291.     char aspTimeout;            /*Timeout for ATP*/
  292.     char aspRetry;                /*Retry count for ATP*/
  293.     short cbSize;                /*Command block size*/
  294.     Ptr cbPtr;                    /*Command block pointer*/
  295.     short rbSize;                /*Reply buffer size*/
  296.     Ptr rbPtr;                    /*Reply buffer pointer*/
  297.     short wdSize;                /*Write Data size*/
  298.     Ptr wdPtr;                    /*Write Data pointer*/
  299.     char ccbStart[296];         /*CCB memory allocated for driver afpWrite max size(CCB)=296 all other calls=150*/
  300. }XPPPrmBlk;
  301.  
  302. typedef struct {
  303.     XPPPBHeader 
  304.     short sessRefnum;            /*Offset to session refnum */
  305.     char aspTimeout;            /*Timeout for ATP */
  306.     char aspRetry;                /*Retry count for ATP */
  307.     short cbSize;                /*Command block size */
  308.     Ptr cbPtr;                    /*Command block pointer */
  309.     short rbSize;                /*Reply buffer size */
  310.     Ptr rbPtr;                    /*Reply buffer pointer */
  311.     AddrBlock afpAddrBlock;     /*block in AFP login */
  312.     Ptr afpSCBPtr;                /*SCB pointer in AFP login */
  313.     Ptr afpAttnRoutine;         /*routine pointer in AFP login */
  314.     char ccbFill[144];            /*CCB memory allocated for driver  Login needs only 150 bytes BUT CCB really starts in the middle of AFPSCBPtr and also clobbers AFPAttnRoutine. */
  315. }AFPLoginPrm;
  316.  
  317. typedef struct {
  318.     XPPPBHeader 
  319.     short sessRefnum;            /*Offset to session refnum */
  320.     char aspTimeout;            /*Timeout for ATP */
  321.     char aspRetry;                /*Retry count for ATP */
  322.     AddrBlock serverAddr;        /*Server address block */
  323.     Ptr scbPointer;             /*SCB pointer */
  324.     Ptr attnRoutine;            /*Attention routine pointer*/
  325. }ASPOpenPrm;
  326.  
  327. typedef ASPOpenPrm *ASPOpenPrmPtr;
  328.  
  329. typedef struct {
  330.     XPPPBHeader 
  331.     Ptr abortSCBPtr;            /*SCB pointer for AbortOS */
  332. }ASPAbortPrm;
  333.  
  334. typedef struct {
  335.     XPPPBHeader 
  336.     short aspMaxCmdSize;        /*For SPGetParms*/
  337.     short aspQuantumSize;
  338.     short numSesss;
  339. }ASPGetparmsBlk;
  340.  
  341. typedef struct {
  342.     short entryLength;
  343.     Ptr entryPtr;
  344. }WDSElement;
  345.  
  346. typedef struct {
  347.     AddrBlock nteAddress;        /*network address of entity*/
  348.     char filler;
  349.     char entityData[99];        /*Object, Type & Zone*/
  350. }NTElement;
  351.  
  352. typedef struct {
  353.     Ptr qNext;                    /*ptr to next NTE*/
  354.     NTElement nt;
  355. }NamesTableEntry;
  356.  
  357. #define MPPATPHeader \
  358.     QElem *qLink;                /*next queue entry*/\
  359.     short qType;                /*queue type*/\
  360.     short ioTrap;                /*routine trap*/\
  361.     Ptr ioCmdAddr;                /*routine address*/\
  362.     ProcPtr ioCompletion;        /*completion routine*/\
  363.     OSErr ioResult;             /*result code*/\
  364.     long userData;                /*Command result (ATP user bytes)*/\
  365.     short reqTID;                /*request transaction ID*/\
  366.     short ioRefNum;             /*driver reference number*/\
  367.     short csCode;                /*Call command code*/
  368.  
  369.  
  370. typedef struct {
  371.     MPPATPHeader
  372. }MPPparms;
  373.  
  374. typedef struct {
  375.     MPPATPHeader
  376.     char protType;                /*ALAP protocol Type */
  377.     char filler;
  378.     union {
  379.         Ptr wdsPointer;         /*-> write data structure*/
  380.         Ptr handler;            /*-> protocol handler routine*/
  381.         } LAPptrs;
  382. }LAPparms;
  383.  
  384. typedef struct {
  385.     MPPATPHeader
  386.     char socket;                /*socket number */
  387.     char checksumFlag;            /*check sum flag */
  388.     union {
  389.         Ptr wdsPointer;         /*-> write data structure*/
  390.         Ptr listener;            /*->write data structure or -> Listener*/
  391.         } DDPptrs;
  392. }DDPparms;
  393.  
  394. typedef struct {
  395.     MPPATPHeader
  396.     char interval;                /*retry interval */
  397.     char count;                 /*retry count */
  398.     union {
  399.         Ptr ntQElPtr;
  400.         Ptr entityPtr;
  401.         } NBPPtrs;
  402.     union {
  403.         char verifyFlag;
  404.         struct {
  405.             Ptr retBuffPtr;
  406.             short retBuffSize;
  407.             short maxToGet;
  408.             short numGotten;
  409.             } Lookup;
  410.         struct {
  411.             AddrBlock confirmAddr;
  412.             char newSocket;
  413.             } Confirm;
  414.         } parm;
  415. }NBPparms;
  416.  
  417. typedef struct {
  418.     MPPATPHeader
  419.     char newSelfFlag;            /*self-send toggle flag */
  420.     char oldSelfFlag;            /*previous self-send state */
  421. }SetSelfparms;
  422.  
  423. typedef struct {
  424.     MPPATPHeader
  425.     Ptr nKillQEl;                /*ptr to i/o queue element to cancel */
  426. }NBPKillparms;
  427.  
  428. typedef union {
  429.     MPPparms MPP;                /*General MPP parms*/
  430.     LAPparms LAP;                /*ALAP calls*/
  431.     DDPparms DDP;                /*DDP calls*/
  432.     NBPparms NBP;                /*NBP calls*/
  433.     SetSelfparms SETSELF ;
  434.     NBPKillparms NBPKILL ;
  435. }MPPParamBlock;
  436.  
  437. typedef MPPParamBlock *MPPPBPtr;
  438.  
  439. #define MOREATPHeader \
  440.     char atpSocket;             /*currbitmap for requests or ATP socket number*/\
  441.     char atpFlags;                /*control information*/\
  442.     AddrBlock addrBlock;        /*source/dest. socket address*/\
  443.     short reqLength;            /*request/response length*/\
  444.     Ptr reqPointer;             /*->request/response Data*/\
  445.     Ptr bdsPointer;             /*->response BDS */
  446.  
  447.  
  448. typedef struct {
  449.     MPPATPHeader
  450.     MOREATPHeader
  451. }ATPparms;
  452.  
  453. typedef struct {
  454.     MPPATPHeader
  455.     MOREATPHeader
  456.     char filler;                /*numOfBuffs */
  457.     char timeOutVal;            /*timeout interval */
  458.     char numOfResps;            /*number of responses actually received */
  459.     char retryCount;            /*number of retries */
  460.     short intBuff;                /*used internally for NSendRequest */
  461. }SendReqparms;
  462.  
  463. typedef struct {
  464.     MPPATPHeader
  465.     MOREATPHeader
  466.     union {
  467.         char bitMap;            /*bitmap received */
  468.         char numOfBuffs;        /*number of responses being sent*/
  469.         char rspNum;            /*sequence number*/
  470.         } u0;
  471. }ATPmisc1;
  472.  
  473. typedef struct {
  474.     MPPATPHeader
  475.     MOREATPHeader
  476.     char filler;
  477.     char bdsSize;                /*number of BDS elements */
  478.     short transID;                /*transaction ID recd. */
  479. }ATPmisc2;
  480.  
  481. typedef struct {
  482.     MPPATPHeader
  483.     MOREATPHeader
  484.     Ptr aKillQEl;                /*ptr to i/o queue element to cancel*/
  485. }Killparms;
  486.  
  487. typedef union {
  488.     ATPparms ATP;                /*General ATP parms*/
  489.     SendReqparms SREQ;            /*sendrequest parms*/
  490.     ATPmisc1 OTH1;                /*and a few others*/
  491.     ATPmisc2 OTH2;                /*and a few others*/
  492.     Killparms KILL;             /*and a few others */
  493. }ATPParamBlock;
  494.  
  495. typedef ATPParamBlock *ATPPBPtr;
  496.  
  497. typedef union {
  498.     XPPPrmBlk XPP;
  499.     ASPGetparmsBlk GETPARM;
  500.     ASPAbortPrm ABORT;
  501.     ASPOpenPrm OPEN;
  502.     AFPLoginPrm LOGIN;
  503. }XPPParamBlock;
  504.  
  505. typedef XPPParamBlock *XPPParmBlkPtr;
  506.  
  507. #ifdef __cplusplus
  508. extern "C" {
  509. #endif
  510. pascal OSErr OpenXPP(short *xppRefnum); 
  511. pascal OSErr ASPOpenSession(ASPOpenPrmPtr thePBptr,Boolean async);
  512. pascal OSErr ASPCloseSession(XPPParmBlkPtr thePBptr,Boolean async); 
  513. pascal OSErr ASPAbortOS(XPPParmBlkPtr thePBptr,Boolean async);
  514. pascal OSErr ASPGetParms(XPPParmBlkPtr thePBptr,Boolean async); 
  515. pascal OSErr ASPCloseAll(XPPParmBlkPtr thePBptr,Boolean async); 
  516. pascal OSErr ASPUserWrite(XPPParmBlkPtr thePBptr,Boolean async);
  517. pascal OSErr ASPUserCommand(XPPParmBlkPtr thePBptr,Boolean async);
  518. pascal OSErr ASPGetStatus(XPPParmBlkPtr thePBptr,Boolean async);
  519. pascal OSErr AFPCommand(XPPParmBlkPtr thePBptr,Boolean async);
  520. pascal OSErr PAttachPH(MPPPBPtr thePBptr,Boolean async);
  521. pascal OSErr PDetachPH(MPPPBPtr thePBptr,Boolean async);
  522. pascal OSErr PWriteLAP(MPPPBPtr thePBptr,Boolean async);
  523. pascal OSErr POpenSkt(MPPPBPtr thePBptr,Boolean async); 
  524. pascal OSErr PCloseSkt(MPPPBPtr thePBptr,Boolean async);
  525. pascal OSErr PWriteDDP(MPPPBPtr thePBptr,Boolean async);
  526. pascal OSErr PRegisterName(MPPPBPtr thePBptr,Boolean async);
  527. pascal OSErr PLookupName(MPPPBPtr thePBptr,Boolean async);
  528. pascal OSErr PConfirmName(MPPPBPtr thePBptr,Boolean async); 
  529. pascal OSErr PRemoveName(MPPPBPtr thePBptr,Boolean async);
  530. pascal OSErr PSetSelfSend(MPPPBPtr thePBptr,Boolean async); 
  531. pascal OSErr PKillNBP(MPPPBPtr thePBptr,Boolean async); 
  532. pascal OSErr POpenATPSkt(ATPPBPtr thePBptr,Boolean async);
  533. pascal OSErr PCloseATPSkt(ATPPBPtr thePBPtr,Boolean async); 
  534. pascal OSErr PSendRequest(ATPPBPtr thePBPtr,Boolean async); 
  535. pascal OSErr PGetRequest(ATPPBPtr thePBPtr,Boolean async);
  536. pascal OSErr PSendResponse(ATPPBPtr thePBPtr,Boolean async);
  537. pascal OSErr PAddResponse(ATPPBPtr thePBPtr,Boolean async); 
  538. pascal OSErr PRelTCB(ATPPBPtr thePBPtr,Boolean async);
  539. pascal OSErr PRelRspCB(ATPPBPtr thePBPtr,Boolean async);
  540. pascal OSErr PNSendRequest(ATPPBPtr thePBPtr,Boolean async);
  541. pascal OSErr PKillSendReq(ATPPBPtr thePBPtr,Boolean async); 
  542. pascal OSErr PKillGetReq(ATPPBPtr thePBPtr,Boolean async);
  543. pascal void BuildLAPwds(Ptr wdsPtr,Ptr dataPtr,short destHost,short prototype,
  544.     short frameLen);
  545. pascal void BuildDDPwds(Ptr wdsPtr,Ptr headerPtr,Ptr dataPtr,const AddrBlock *netAddr,
  546.     short ddpType,short dataLen);
  547. pascal void NBPSetEntity(Ptr buffer,Ptr nbpObject,Ptr nbpType,Ptr nbpZone); 
  548. pascal void NBPSetNTE(Ptr ntePtr,Ptr nbpObject,Ptr nbpType,Ptr nbpZone,
  549.     short socket);
  550. pascal short GetBridgeAddress(void);
  551. pascal short BuildBDS(Ptr buffPtr,Ptr bdsPtr,short buffSize);
  552. pascal OSErr MPPOpen(void); 
  553. pascal OSErr MPPClose(void);
  554. pascal OSErr LAPOpenProtocol(ABByte theLAPType,Ptr protoPtr);
  555. pascal OSErr LAPCloseProtocol(ABByte theLAPType);
  556. pascal OSErr LAPWrite(ATLAPRecHandle abRecord,Boolean async);
  557. pascal OSErr LAPRead(ATLAPRecHandle abRecord,Boolean async);
  558. pascal OSErr LAPRdCancel(ATLAPRecHandle abRecord);
  559. pascal OSErr DDPOpenSocket(short *theSocket,Ptr sktListener);
  560. pascal OSErr DDPCloseSocket(short theSocket);
  561. pascal OSErr DDPRead(ATDDPRecHandle abRecord,Boolean retCksumErrs,Boolean async);
  562. pascal OSErr DDPWrite(ATDDPRecHandle abRecord,Boolean doChecksum,Boolean async);
  563. pascal OSErr DDPRdCancel(ATDDPRecHandle abRecord);
  564. pascal OSErr ATPLoad(void); 
  565. pascal OSErr ATPUnload(void);
  566. pascal OSErr ATPOpenSocket(const AddrBlock *addrRcvd,short *atpSocket); 
  567. pascal OSErr ATPCloseSocket(short atpSocket);
  568. pascal OSErr ATPSndRequest(ATATPRecHandle abRecord,Boolean async);
  569. pascal OSErr ATPRequest(ATATPRecHandle abRecord,Boolean async); 
  570. pascal OSErr ATPReqCancel(ATATPRecHandle abRecord,Boolean async);
  571. pascal OSErr ATPGetRequest(ATATPRecHandle abRecord,Boolean async);
  572. pascal OSErr ATPSndRsp(ATATPRecHandle abRecord,Boolean async);
  573. pascal OSErr ATPAddRsp(ATATPRecHandle abRecord);
  574. pascal OSErr ATPResponse(ATATPRecHandle abRecord,Boolean async);
  575. pascal OSErr ATPRspCancel(ATATPRecHandle abRecord,Boolean async);
  576. pascal OSErr NBPRegister(ATNBPRecHandle abRecord,Boolean async);
  577. pascal OSErr NBPLookup(ATNBPRecHandle abRecord,Boolean async);
  578. pascal OSErr NBPExtract(Ptr theBuffer,short numInBuf,short whichOne,EntityName *abEntity,
  579.     AddrBlock *address);
  580. pascal OSErr NBPConfirm(ATNBPRecHandle abRecord,Boolean async); 
  581. pascal OSErr NBPRemove(EntityPtr abEntity); 
  582. pascal OSErr NBPLoad(void); 
  583. pascal OSErr NBPUnload(void);
  584. pascal void RemoveHdlBlocks(void);
  585. pascal OSErr GetNodeAddress(short *myNode,short *myNet);
  586. pascal Boolean IsMPPOpen(void); 
  587. pascal Boolean IsATPOpen(void); 
  588. #ifdef __cplusplus
  589. }
  590. #endif
  591.  
  592. #endif
  593.